using System.Windows;
using Microsoft.Win32;
using WpfApp_ChenxiConsole.OTA;
using WpfApp_ChenxiConsole.FileIO;
using System.IO;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Data;
using System.ComponentModel;
using System.Text;
using System.Text.Json;
using WpfApp_ChenxiConsole.Controls;
using System.Diagnostics;
using System.Net;
using System.Net.Http;
using System.Net.Sockets;
using System.Threading.Tasks;
using WpfApp_ChenxiConsole.TCP;

namespace WpfApp_ChenxiConsole
{
    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : Window
    {
        private readonly FileLoader _fileLoader;
        private EcuOtaManager _ecuOtaManager;

        public MainWindow()
        {
            // 添加全局异常处理器
            AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
            Dispatcher.UnhandledException += Dispatcher_UnhandledException;
            TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException;

            InitializeComponent();
            _fileLoader = new FileLoader();
            _ecuOtaManager = new EcuOtaManager();
            
            // 注册消息过滤器处理器，将cmd为996的JSON消息添加到ECU升级窗口的接收队列
            MessageFilter.RegisterHandler("EcuOtaHandler", message =>
            {
                try
                {
                    EcuOtaManager.AddToReceivedQueue(message);
                }
                catch (Exception ex)
                {
                    LogException(ex, "添加消息到ECU升级窗口接收队列失败");
                }
            });
            
            // 在主界面启动前执行联网验证
            PerformNetworkValidation();
        }
        
        /// <summary>
        /// 主界面启动前执行的联网验证功能
        /// </summary>
        private void PerformNetworkValidation()
        {
            try
            {
                // 显示加载指示器或验证中提示
                ShowValidationInProgress();
                
                // 异步执行联网验证，避免阻塞UI线程
                Task.Run(async () =>
                {
                    bool validationResult = await ValidateNetworkConnectionAsync();
                    
                    // 在UI线程上处理验证结果
                    this.Dispatcher.Invoke(() =>
                    {
                        if (validationResult)
                        {
                            // 验证成功，继续启动UI
                            HandleValidationResult(true);
                        }
                        else
                        {
                            // 验证失败，直接结束程序
                            LogException(new Exception("联网验证失败，返回值为0"), "联网验证失败");
                            
                            // 显示错误信息后关闭应用
                            // MessageBox.Show(
                            //     "验证失败，应用程序无法启动。",
                            //     "验证失败",
                            //     MessageBoxButton.OK,
                            //     MessageBoxImage.Error);
                            
                            // 立即关闭应用程序，不启动UI
                            Application.Current.Shutdown();
                        }
                    });
                });
            }
            catch (Exception ex)
            {
                LogException(ex, "联网验证启动失败");
                
                // 隐藏加载指示器
                HideValidationInProgress();
                
                // 发生异常时直接关闭应用程序，不显示错误对话框
                // Debug.WriteLine("联网验证过程中发生错误，即将关闭应用程序");
                Application.Current.Shutdown();
            }
        }
        
        /// <summary>
        /// 异步执行联网验证的核心方法
        /// 连接到指定服务器并发送验证数据
        /// </summary>
        /// <returns>验证是否成功（返回1为成功，返回0为失败）</returns>
        private async Task<bool> ValidateNetworkConnectionAsync()
        {
            TcpClient? client = null;
            NetworkStream? stream = null;
            
            try
            {
                // 服务器地址和端口
                string serverIp = "58.16.96.195";
                int serverPort = 60003;
                
                // 创建TCP客户端并连接到服务器
                client = new TcpClient();
                await client.ConnectAsync(serverIp, serverPort);
                // Debug.WriteLine($"已连接到服务器: {serverIp}:{serverPort}");
                
                // 获取网络流
                stream = client.GetStream();
                
                // 准备要发送的JSON数据
                string jsonData = "{\"Cmd\":4,\"UniqueId\":\"ceshi\"}";
                byte[] dataToSend = Encoding.UTF8.GetBytes(jsonData);
                
                // 发送数据
                await stream.WriteAsync(dataToSend, 0, dataToSend.Length);
                // Debug.WriteLine($"已发送数据: {jsonData}");
                
                // 接收服务器返回的数据
                byte[] buffer = new byte[1024];
                int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length);
                
                // 处理返回结果
                if (bytesRead > 0)
                {
                    string response = Encoding.UTF8.GetString(buffer, 0, bytesRead);
                    // Debug.WriteLine($"收到服务器响应: {response}");
                    
                    // 检查返回值是否为1或0
                    // 假设服务器返回的是纯文本的"1"或"0"
                    if (response.Trim() == "1")
                    {
                        return true; // 验证成功
                    }
                    else if (response.Trim() == "0")
                    {
                        return false; // 验证失败
                    }
                    else
                    {
                        // 处理意外的响应格式
                        LogException(new Exception($"服务器返回了意外的响应格式: {response}"), "联网验证响应格式错误");
                        return false;
                    }
                }
                else
                {
                    // 未收到数据
                    LogException(new Exception("未收到服务器返回的数据"), "联网验证无响应");
                    return false;
                }
            }
            catch (Exception ex)
            {
                LogException(ex, "联网验证执行失败");
                return false;
            }
            finally
            {
                // 确保释放资源
                if (stream != null)
                    stream.Close();
                
                if (client != null)
                    client.Close();
            }
        }
        
        /// <summary>
        /// 显示验证进行中的UI提示
        /// </summary>
        private void ShowValidationInProgress()
        {
            // TODO: 实现显示验证进行中的UI元素
            // 例如：显示加载动画、禁用主要UI元素等
            // Debug.WriteLine("开始联网验证...");
        }
        
        /// <summary>
        /// 隐藏验证进行中的UI提示
        /// </summary>
        private void HideValidationInProgress()
        {
            // TODO: 实现隐藏验证进行中的UI元素
            // Debug.WriteLine("联网验证UI提示已隐藏");
        }
        
        /// <summary>
        /// 处理联网验证的结果
        /// </summary>
        /// <param name="isValidated">验证是否成功</param>
        private void HandleValidationResult(bool isValidated)
        {
            try
            {
                // 隐藏加载指示器
                HideValidationInProgress();
                
                if (isValidated)
                {
                    // 验证成功，允许应用程序继续运行
                    // Debug.WriteLine("联网验证成功");
                }
                else
                {
                    // 验证失败，直接关闭应用程序
                    // Debug.WriteLine("联网验证失败，即将关闭应用程序");
                    Application.Current.Shutdown();
                }
            }
            catch (Exception ex)
            {
                LogException(ex, "处理验证结果时发生错误");
                // 发生异常时也关闭应用程序
                Application.Current.Shutdown();
            }
        }

        private void TaskScheduler_UnobservedTaskException(object? sender, UnobservedTaskExceptionEventArgs e)
        {
            LogException(e.Exception, "TaskScheduler Unobserved Exception");
            e.SetObserved();
        }

        private void Dispatcher_UnhandledException(object? sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
        {
            LogException(e.Exception, "Dispatcher Unhandled Exception");
            e.Handled = true;
        }

        private void CurrentDomain_UnhandledException(object? sender, UnhandledExceptionEventArgs e)
        {
            if (e.ExceptionObject is Exception ex)
            {
                LogException(ex, "AppDomain Unhandled Exception");
            }
        }

        private void LogException(Exception ex, string source)
        {
            string logMessage = $"[{DateTime.Now:yyyy-MM-dd HH:mm:ss}] {source}: {ex.Message}\r\n" +
                               $"Stack Trace: {ex.StackTrace}\r\n" +
                               $"Inner Exception: {ex.InnerException?.Message}\r\n" +
                               "-------------------------------------------\r\n";
            
            // 在调试模式下显示异常信息
            Debug.WriteLine(logMessage);
        }

        /// <summary>
        /// 打开BIN文件的事件处理程序
        /// </summary>
        /// <param name="sender">事件发送者</param>
        /// <param name="e">事件参数</param>
        private void OpenBinFile_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                OpenFileDialog openFileDialog = new();
                {
                    openFileDialog.Filter = "BIN文件 (*.bin)|*.bin|所有文件 (*.*)|*.*";
                    Title = "打开BIN文件";
                };

                if (openFileDialog.ShowDialog() == true)
                {
                    string filePath = openFileDialog.FileName;
                    
                    // 加载BIN文件
                    byte[] fileContent = _fileLoader.LoadBinFile(filePath);
                    
                    // 显示加载成功的消息
                    MessageBox.Show(
                        $"BIN文件加载成功！\n文件名: {Path.GetFileName(filePath)}\n文件大小: {fileContent.Length} 字节",
                        "成功",
                        MessageBoxButton.OK,
                        MessageBoxImage.Information);
                    
                    // 这里可以添加处理文件内容的代码
                    // 例如：将文件内容显示在界面上，或者传递给其他组件进行处理
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(
                    $"加载BIN文件时发生错误：{ex.Message}",
                    "错误",
                    MessageBoxButton.OK,
                    MessageBoxImage.Error);
            }
        }

        /// <summary>
        /// 打开HEX文件的事件处理程序
        /// </summary>
        /// <param name="sender">事件发送者</param>
        /// <param name="e">事件参数</param>
        private void OpenHexFile_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                OpenFileDialog openFileDialog = new();
                {
                    openFileDialog.Filter = "HEX文件 (*.hex)|*.hex|所有文件 (*.*)|*.*";
                    openFileDialog.Title = "打开HEX文件";
                };

                if (openFileDialog.ShowDialog() == true)
                {
                    string filePath = openFileDialog.FileName;
                    
                    // 加载HEX文件
                    byte[] fileContent = _fileLoader.LoadHexFile(filePath);
                    
                    // 显示加载成功的消息
                    MessageBox.Show(
                        $"HEX文件加载成功！\n文件名: {Path.GetFileName(filePath)}\n解析后数据大小: {fileContent.Length} 字节",
                        "成功",
                        MessageBoxButton.OK,
                        MessageBoxImage.Information);
                    
                    // 这里可以添加处理文件内容的代码
                    // 例如：将文件内容显示在界面上，或者传递给其他组件进行处理
                }
            } catch (Exception ex)
            {
                MessageBox.Show(
                    $"加载HEX文件时发生错误：{ex.Message}",
                    "错误",
                    MessageBoxButton.OK,
                    MessageBoxImage.Error);
            }
        }

        /// <summary>
        /// 查看已加载文件的事件处理程序
        /// </summary>
        /// <param name="sender">事件发送者</param>
        /// <param name="e">事件参数</param>
        private void ViewLoadedFiles_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                // 创建一个新窗口
                Window filesWindow = new Window
                {
                    Title = "已加载文件",
                    Width = 900,
                    Height = 600,
                    MinWidth = 700,
                    MinHeight = 500,
                    Background = new SolidColorBrush(Color.FromRgb(245, 245, 247)),
                    ResizeMode = ResizeMode.CanResizeWithGrip
                };

                // 创建LoadedFilesViewer控件
                LoadedFilesViewer filesViewer = new LoadedFilesViewer();
                
                // 设置文件列表
                filesViewer.SetFiles(_fileLoader.LoadedFiles);
                
                // 绑定关闭事件
                filesViewer.CloseButtonClick += (s, args) => filesWindow.Close();

                // 设置窗口内容
                filesWindow.Content = filesViewer;

                // 显示窗口
                filesWindow.ShowDialog();
            }
            catch (Exception ex)
            {
                MessageBox.Show(
                    $"查看已加载文件时发生错误：{ex.Message}",
                    "错误",
                    MessageBoxButton.OK,
                    MessageBoxImage.Error);
            }
        }

        /// <summary>
        /// 清除已加载文件记录的事件处理程序
        /// </summary>
        /// <param name="sender">事件发送者</param>
        /// <param name="e">事件参数</param>
        private void ClearLoadedFiles_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                // 显示确认对话框
                MessageBoxResult result = MessageBox.Show(
                    "确定要清除所有已加载文件的记录吗？",
                    "确认清除",
                    MessageBoxButton.YesNo,
                    MessageBoxImage.Question);

                if (result == MessageBoxResult.Yes)
                {
                    // 清除已加载文件记录
                    _fileLoader.ClearLoadedFiles();
                    MessageBox.Show(
                        "已成功清除所有已加载文件的记录。",
                        "成功",
                        MessageBoxButton.OK,
                        MessageBoxImage.Information);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(
                    $"清除已加载文件记录时发生错误：{ex.Message}",
                    "错误",
                    MessageBoxButton.OK,
                    MessageBoxImage.Error);
            }
        }
        /// <summary>
        /// OTA升级菜单点击事件处理程序
        /// </summary>
        /// <param name="sender">事件发送者</param>
        /// <param name="e">事件参数</param>
        private void OtaUpgrade_Click(object sender, RoutedEventArgs e)
        {
            // 只有当直接点击"OTA升级"父菜单项时才显示提示
            // 避免点击子菜单项时触发提示
        }

        /// <summary>
        /// OTA升级底层控制单元(ECU)子菜单点击事件处理程序
        /// </summary>
        /// <param name="sender">事件发送者</param>
        /// <param name="e">事件参数</param>
        /// <summary>
        /// 临时调试方法：检查所有TCP客户端的连接状态
        /// </summary>
        private void CheckAllTcpClientsStatus()
        {
            StringBuilder statusInfo = new StringBuilder("所有TCP客户端状态:\n");
            int totalTabs = 0;
            int tcpTabs = 0;
            int connectedTcpTabs = 0;
            
            foreach (TabItem tabItem in MainTabControl.Items)
            {
                totalTabs++;
                string? headerText = tabItem.Header?.ToString() ?? "[无标题]";
                
                if (headerText.Contains("TCP"))
                {
                    tcpTabs++;
                    statusInfo.AppendLine($"\n选项卡 {totalTabs}: {headerText}");
                    statusInfo.AppendLine($"  内容类型: {tabItem.Content?.GetType().Name ?? "空"}");
                    
                    if (tabItem.Content is TCP.TcpConsoleControl tcpConsole)
                    {
                        bool isConnected = tcpConsole.IsConnected;
                        statusInfo.AppendLine($"  连接状态: {isConnected}");
                        
                        if (tcpConsole.TcpClientManager != null)
                        {
                            statusInfo.AppendLine("  TcpClientManager: 已创建");
                        }
                        else
                        {
                            statusInfo.AppendLine("  TcpClientManager: 未创建");
                        }
                        
                        if (isConnected)
                        {
                            connectedTcpTabs++;
                        }
                    }
                }
            }
            
            statusInfo.AppendLine($"\n统计信息:");
            statusInfo.AppendLine($"总选项卡数: {totalTabs}");
            statusInfo.AppendLine($"TCP相关选项卡数: {tcpTabs}");
            statusInfo.AppendLine($"已连接的TCP客户端数: {connectedTcpTabs}");
            
            MessageBox.Show(statusInfo.ToString(), "TCP客户端状态检查");
        }
        
        private void OtaUpgradeJson_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                // 先执行TCP客户端的状态统计，但不显示弹窗
                // CheckAllTcpClientsStatus(); // 注释掉弹窗显示，但保留统计功能
                
                // 收集所有已连接的TCP客户端选项卡
                List<(string TabHeader, TCP.TcpConsoleControl TcpConsole)> tcpClients = new List<(string, TCP.TcpConsoleControl)>();
                
                // 调试：记录找到的TCP客户端数量
                int foundTcpClients = 0;
                int totalTcpTabs = 0;
                string debugInfo = "TCP客户端选项卡信息:\n";
                
                foreach (TabItem tabItem in MainTabControl.Items)
                {
                    string? headerText = tabItem.Header?.ToString();
                    if (headerText != null && 
                        (headerText.Contains("TCP客户端") || 
                         headerText.Contains("TCP 连接") || 
                         headerText.Contains("TCP")))
                    {
                        totalTcpTabs++;
                        bool isConsoleControl = tabItem.Content is TCP.TcpConsoleControl;
                        bool isConnected = false;
                        
                        debugInfo += $"- 标题: {headerText}, 是TcpConsoleControl: {isConsoleControl}";
                        
                        if (isConsoleControl)
                        {
                            var tcpConsoleControl = (TCP.TcpConsoleControl)tabItem.Content;
                            isConnected = tcpConsoleControl.IsConnected;
                            debugInfo += $", 连接状态: {isConnected}";
                            
                            // 只添加已连接的客户端
                            if (isConnected)
                            {
                                tcpClients.Add((headerText, tcpConsoleControl));
                                foundTcpClients++;
                            }
                        }
                        debugInfo += "\n";
                    }
                }
                
                // 显示调试信息
                debugInfo += $"\n找到的TCP选项卡总数: {totalTcpTabs}\n";
                debugInfo += $"已连接的TCP客户端数量: {foundTcpClients}";
                // MessageBox.Show(debugInfo, "调试信息"); // 注释掉调试信息弹窗显示
                
                TCP.TcpConsoleControl? selectedTcpConsole = null;
                string? selectedTabHeader = null;
                
                // 如果有多个TCP客户端，显示选择对话框
                if (tcpClients.Count > 1)
                {
                    // 确保对话框始终显示在最前面
                    OTA.TcpClientSelectorDialog selectorDialog = new OTA.TcpClientSelectorDialog(tcpClients);
                    selectorDialog.Topmost = true; // 确保对话框在最上层
                    if (selectorDialog.ShowDialog() == true)
                    {
                        selectedTcpConsole = selectorDialog.SelectedTcpConsoleControl;
                        // 查找选中的控制台对应的选项卡标题
                        var selectedClient = tcpClients.Find(client => client.TcpConsole == selectedTcpConsole);
                        if (selectedClient != default)
                        {
                            selectedTabHeader = selectedClient.TabHeader;
                        }
                    }
                    else
                    {
                        // 用户取消了选择，不打开OTA窗口
                        return;
                    }
                }
                else if (tcpClients.Count == 1)
                {
                    // 只有一个TCP客户端，直接使用
                    selectedTcpConsole = tcpClients[0].TcpConsole;
                    selectedTabHeader = tcpClients[0].TabHeader;
                }
                
                // 打开ECU OTA配置窗口
                EcuOtaConfigWindow configWindow = new EcuOtaConfigWindow(selectedTcpConsole, selectedTabHeader);
                configWindow.Owner = this;
                configWindow.ShowDialog();
            }
            catch (Exception ex)
            {
                MessageBox.Show(
                        $"打开ECU OTA配置窗口时发生错误：{ex.Message}",
                        "错误",
                        MessageBoxButton.OK,
                        MessageBoxImage.Error);
            }
        }

        /// <summary>
        /// 底层单元OTA升级菜单项点击事件处理程序
        /// </summary>
        /// <param name="sender">事件发送者</param>
        /// <param name="e">事件参数</param>
        private void BottomUnitOta_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                // 收集所有已连接的TCP客户端选项卡
                List<(string TabHeader, TCP.TcpConsoleControl TcpConsole)> tcpClients = new List<(string, TCP.TcpConsoleControl)>();
                
                // 调试：记录找到的TCP客户端数量
                int foundTcpClients = 0;
                
                foreach (TabItem tabItem in MainTabControl.Items)
                {
                    string? headerText = tabItem.Header?.ToString();
                    // 更宽松的匹配条件，只收集已连接的TCP客户端
                    if (headerText != null && 
                        (headerText.Contains("TCP客户端") || 
                         headerText.Contains("TCP 连接") || 
                         headerText.Contains("TCP")) && 
                        tabItem.Content is TCP.TcpConsoleControl tcpConsoleControl &&
                        tcpConsoleControl.IsConnected) // 只添加已连接的客户端
                    {
                        tcpClients.Add((headerText, tcpConsoleControl));
                        foundTcpClients++;
                    }
                }
                
                // 调试：显示找到的TCP客户端数量
                // MessageBox.Show($"找到 {foundTcpClients} 个TCP客户端选项卡", "调试信息");
                
                TCP.TcpConsoleControl? selectedTcpConsole = null;
                
                // 如果有多个TCP客户端，显示选择对话框
                if (tcpClients.Count > 1)
                {
                    // 确保对话框始终显示在最前面
                    OTA.TcpClientSelectorDialog selectorDialog = new OTA.TcpClientSelectorDialog(tcpClients);
                    selectorDialog.Topmost = true; // 确保对话框在最上层
                    if (selectorDialog.ShowDialog() == true)
                    {
                        selectedTcpConsole = selectorDialog.SelectedTcpConsoleControl;
                    }
                    else
                    {
                        // 用户取消了选择，不打开OTA窗口
                        return;
                    }
                }
                else if (tcpClients.Count == 1)
                {
                    // 只有一个TCP客户端，直接使用
                    selectedTcpConsole = tcpClients[0].TcpConsole;
                }
                
                // 打开底层单元OTA升级窗口
                OTA.BottomUnitOtaWindow bottomUnitWindow = new OTA.BottomUnitOtaWindow(selectedTcpConsole);
                bottomUnitWindow.Owner = this;
                bottomUnitWindow.ShowDialog();
            }
            catch (Exception ex)
            {
                MessageBox.Show(
                    $"打开底层单元OTA升级窗口时发生错误：{ex.Message}",
                    "错误",
                    MessageBoxButton.OK,
                    MessageBoxImage.Error);
            }
        }

        /// <summary>
        /// 添加选项卡按钮点击事件处理程序
        /// </summary>
        /// <param name="sender">事件发送者</param>
        /// <param name="e">事件参数</param>
        private void AddTabButton_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                // 创建一个新的选项卡
                TabItem newTabItem = new TabItem();
                
                // 获取当前TCP和UDP选项卡的数量，以确定新选项卡的类型和标题
                int tcpTabCount = 0;
                int udpTabCount = 0;
                
                foreach (TabItem tabItem in MainTabControl.Items)
                {
                    string? headerText = tabItem.Header?.ToString();
                    if (headerText != null && headerText.Contains("TCP"))
                    {
                        tcpTabCount++;
                    }
                    else if (headerText != null && headerText.Contains("UDP"))
                    {
                        udpTabCount++;
                    }
                }
                
                // 如果TCP选项卡数量少于UDP选项卡数量，添加TCP选项卡，否则添加UDP选项卡
                if (tcpTabCount <= udpTabCount)
                {
                    newTabItem.Header = tcpTabCount == 0 ? "TCP 连接" : $"TCP 连接 {tcpTabCount + 1}";
                    newTabItem.Content = new TCP.TcpConsoleControl();
                }
                else
                {
                    newTabItem.Header = udpTabCount == 0 ? "UDP 控制台" : $"UDP 控制台 {udpTabCount + 1}";
                    newTabItem.Content = new UDP.UdpConsoleControl();
                }
                
                // 添加新选项卡到TabControl
                MainTabControl.Items.Add(newTabItem);
                
                // 选中新添加的选项卡
                MainTabControl.SelectedItem = newTabItem;
            }
            catch (Exception ex)
            {
                MessageBox.Show(
                    $"添加选项卡时发生错误：{ex.Message}",
                    "错误",
                    MessageBoxButton.OK,
                    MessageBoxImage.Error);
            }
        }


        /// <summary>
        /// 添加TCP客户端选项卡
        /// </summary>
        /// <param name="sender">事件发送者</param>
        /// <param name="e">事件参数</param>
        private void AddTcpClientTab_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                // 获取当前TCP客户端选项卡的数量
                int tcpClientCount = 0;
                foreach (TabItem tabItem in MainTabControl.Items)
                {
                    string? headerText = tabItem.Header?.ToString();
                    if (headerText != null && headerText.Contains("TCP客户端"))
                    {
                        tcpClientCount++;
                    }
                }

                // 创建新的TCP客户端选项卡
                TabItem newTabItem = new TabItem();
                newTabItem.Header = tcpClientCount == 0 ? "TCP客户端" : $"TCP客户端 {tcpClientCount + 1}";
                newTabItem.Content = new TCP.TcpConsoleControl();

                // 添加新选项卡到TabControl
                MainTabControl.Items.Add(newTabItem);

                // 选中新添加的选项卡
                MainTabControl.SelectedItem = newTabItem;
            }
            catch (Exception ex)
            {
                MessageBox.Show(
                    $"添加TCP客户端选项卡时发生错误：{ex.Message}",
                    "错误",
                    MessageBoxButton.OK,
                    MessageBoxImage.Error);
            }
        }

        /// <summary>
        /// 添加UDP选项卡
        /// </summary>
        /// <param name="sender">事件发送者</param>
        /// <param name="e">事件参数</param>
        private void AddUdpTab_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                // 获取当前UDP选项卡的数量
                int udpTabCount = 0;
                foreach (TabItem tabItem in MainTabControl.Items)
                {
                    string? headerText = tabItem.Header?.ToString();
                    if (headerText != null && headerText.Contains("UDP"))
                    {
                        udpTabCount++;
                    }
                }

                // 创建新的UDP选项卡
                TabItem newTabItem = new TabItem();
                newTabItem.Header = udpTabCount == 0 ? "UDP控制台" : $"UDP控制台 {udpTabCount + 1}";
                newTabItem.Content = new UDP.UdpConsoleControl();

                // 添加新选项卡到TabControl
                MainTabControl.Items.Add(newTabItem);

                // 选中新添加的选项卡
                MainTabControl.SelectedItem = newTabItem;
            }
            catch (Exception ex)
            {
                MessageBox.Show(
                    $"添加UDP选项卡时发生错误：{ex.Message}",
                    "错误",
                    MessageBoxButton.OK,
                    MessageBoxImage.Error);
            }
        }

        /// <summary>
        /// 移除选项卡按钮点击事件处理程序
        /// </summary>
        /// <param name="sender">事件发送者</param>
        /// <param name="e">事件参数</param>
        private void RemoveTabButton_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                // 确保至少保留一个选项卡
                if (MainTabControl.Items.Count <= 1)
                {
                    MessageBox.Show(
                        "至少需要保留一个选项卡",
                        "提示",
                        MessageBoxButton.OK,
                        MessageBoxImage.Information);
                    return;
                }
                
                // 获取当前选中的选项卡
                TabItem? selectedTabItem = MainTabControl.SelectedItem as TabItem;
                
                if (selectedTabItem != null)
                {
                    // 显示确认对话框
                    MessageBoxResult result = MessageBox.Show(
                        $"确定要移除\"{selectedTabItem.Header}\"选项卡吗？",
                        "确认移除",
                        MessageBoxButton.YesNo,
                        MessageBoxImage.Question);
                    
                    if (result == MessageBoxResult.Yes)
                    {
                        // 移除选中的选项卡
                        MainTabControl.Items.Remove(selectedTabItem);
                        
                        // 重新排序剩余的选项卡标题
                        RenameTabsAfterRemoval();
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(
                    $"移除选项卡时发生错误：{ex.Message}",
                    "错误",
                    MessageBoxButton.OK,
                    MessageBoxImage.Error);
            }
        }

        /// <summary>
        /// 移除选项卡后重新排序剩余选项卡的标题
        /// </summary>
        private void RenameTabsAfterRemoval()
        {
            try
            {
                int tcpClientCount = 1;
                int udpTabCount = 1;
                
                foreach (TabItem tabItem in MainTabControl.Items)
                {
                    string? headerText = tabItem.Header?.ToString();
                    if (headerText != null && headerText.Contains("TCP客户端"))
                    {
                        tabItem.Header = tcpClientCount == 1 ? "TCP客户端" : $"TCP客户端 {tcpClientCount}";
                        tcpClientCount++;
                    }
                    else if (headerText != null && headerText.Contains("UDP"))
                    {
                        tabItem.Header = udpTabCount == 1 ? "UDP控制台" : $"UDP控制台 {udpTabCount}";
                        udpTabCount++;
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(
                    $"重命名选项卡时发生错误：{ex.Message}",
                    "错误",
                    MessageBoxButton.OK,
                    MessageBoxImage.Error);
            }
        }
    }
}